/**
 * JZ UnoCSS - 条件编译器
 * 处理平台特定的CSS生成和条件编译逻辑
 * @version 1.1.0
 * @author jz
 * @updated 根据 uni-app-x CSS 文档更新平台兼容性
 */

import { utils } from '../utils/utils.js';

/**
 * CSS属性平台兼容性配置
 * 基于 uni-app-x CSS 文档的兼容性表格
 */
const CSS_COMPATIBILITY = {
    // 仅App端支持的属性
    'app-only': [
        'lines',                        // App专有的text组件行数限制
        '-webkit-overflow-scrolling'    // App的scrollView优化
    ],
    
    // 仅Web端支持的属性
    'web-only': [
        '-webkit-line-clamp',           // Web多行省略
        '-webkit-box-orient',           // Web flexbox
        'backdrop-filter',              // Web背景滤镜
        'filter',                       // Web滤镜
        'clip-path',                    // Web裁剪路径
        'mask',                         // Web遮罩
        'scroll-behavior',              // Web滚动行为
        'overscroll-behavior',          // Web过度滚动
        'user-select'                   // Web文本选择
    ],
    
    // 部分平台支持的属性（需要条件编译）
    'conditional': [
        'background-clip',              // Web/MP支持全部值，App仅支持border-box
        'text-decoration',              // Web支持全部，App/MP部分支持
        'opacity',                      // 全平台支持但实现不同
        'transform',                    // 全平台支持但语法有差异
        'transition',                   // 全平台支持但属性支持度不同
        'box-shadow',                   // 全平台支持但效果有差异
        'border-radius',                // 全平台支持但圆角计算可能不同
        'display',                      // 部分display值平台支持不同
        'position',                     // sticky等值支持度不同
        'overflow',                     // 部分值平台支持不同
        'white-space',                  // 部分值平台支持不同
        'text-overflow',               // 全平台支持但配合属性不同
        'font-family',                  // 字体支持度不同
        'letter-spacing',               // 实现精度可能不同
        'line-height',                  // 计算方式可能不同
        'text-align'                    // justify等值支持不同
    ],
    
    // 全平台通用属性（无需条件编译）
    'universal': [
        'width', 'height', 'margin', 'padding',
        'background-color', 'color', 'font-size', 'font-weight',
        'border', 'border-width', 'border-color', 'border-style',
        'flex', 'justify-content', 'align-items', 'flex-direction',
        'top', 'left', 'right', 'bottom', 'z-index',
        'min-width', 'max-width', 'min-height', 'max-height'
    ]
};

/**
 * 平台特定的CSS值兼容性
 */
const CSS_VALUE_COMPATIBILITY = {
    'display': {
        'web-only': ['-webkit-box'],
        'conditional': ['flex', 'block', 'inline', 'none', 'inline-block']
    },
    'position': {
        'conditional': ['sticky', 'fixed'],
        'universal': ['static', 'relative', 'absolute']
    },
    'background-clip': {
        'web-mp': ['border-box', 'padding-box', 'content-box', 'text'],
        'app': ['border-box']  // App端仅支持border-box
    },
    'text-decoration': {
        'web': ['none', 'underline', 'overline', 'line-through', 'blink'],
        'app-mp': ['none', 'underline', 'line-through']  // App和MP不支持overline和blink
    }
};

/**
 * 判断CSS属性是否需要条件编译
 * @param {Object} styles - CSS样式对象
 * @param {string} className - 类名
 * @returns {boolean} 是否需要条件编译
 */
export function needsConditionalCompilation(styles, className) {
    // 1. 检查是否包含平台特定的CSS属性
    for (const [property, value] of Object.entries(styles)) {
        // 检查仅特定平台支持的属性
        if (CSS_COMPATIBILITY['app-only'].includes(property) ||
            CSS_COMPATIBILITY['web-only'].includes(property) ||
            CSS_COMPATIBILITY['conditional'].includes(property)) {
            return true;
        }
        
        // 检查属性值的兼容性
        if (typeof value === 'string') {
            // 检查webkit前缀（通常为Web特有）
            if (value.includes('-webkit-') && !property.includes('-webkit-')) {
                return true;
            }
            
            // 检查CSS值兼容性
            if (CSS_VALUE_COMPATIBILITY[property]) {
                const compat = CSS_VALUE_COMPATIBILITY[property];
                if (compat['web-only']?.includes(value) ||
                    compat['app-only']?.includes(value) ||
                    compat['conditional']?.includes(value)) {
                    return true;
                }
            }
            
            // 检查复杂CSS值
            if (value.includes('env(') ||           // 安全区域
                value.includes('var(--') ||         // CSS变量
                value.includes('calc(') && value.includes('env(') ||  // 安全区域计算
                value.includes('-webkit-') ||       // webkit前缀
                value.includes('-moz-') ||          // firefox前缀
                value.includes('-ms-')) {           // IE前缀
                return true;
            }
        }
    }
    
    // 2. 检查特殊的类名模式
    const specialClassPatterns = [
        /^text-ellipsis-\d+$/,          // text-ellipsis-* 需要条件编译
        /^text-ellipsis-\[\d+\]$/,      // text-ellipsis-[*] 需要条件编译
        /^lines-\d+$/,                  // lines-* 仅App支持
        /^lines-\[\d+\]$/,              // lines-[*] 仅App支持
        /^bg-clip-/,                    // background-clip 平台支持不同
        /^backdrop-/,                   // backdrop-filter Web专有
        /^filter-/,                     // filter Web专有
        /^select-/,                     // user-select Web专有
        /^touch-/,                      // touch-action 部分平台支持
        /^scroll-/,                     // scroll-behavior Web专有
        /^overscroll-/,                 // overscroll-behavior Web专有
        /^decoration-/,                 // text-decoration 平台支持不同
        /^break-/,                      // word-break等平台支持不同
        /^overflow-/,                   // overflow值平台支持不同
        /^whitespace-/,                 // white-space值平台支持不同
        /^tracking-/,                   // letter-spacing实现差异
        /^leading-/                     // line-height实现差异
    ];
    
    // 检查类名是否匹配特殊模式
    const decodedClassName = utils.decodeClassNameFromUvue(className);
    if (specialClassPatterns.some(pattern => pattern.test(decodedClassName))) {
        return true;
    }
    
    // 3. 检查组合CSS样式的兼容性
    const styleKeys = Object.keys(styles);
    
    // 多行省略的组合检查
    if (styleKeys.includes('display') && styleKeys.includes('-webkit-line-clamp')) {
        return true;  // Web端多行省略方案
    }
    
    // text组件lines属性检查
    if (styleKeys.includes('lines')) {
        return true;  // App端专有属性
    }
    
    // 4. 默认情况：通用CSS属性不需要条件编译
    return false;
}

/**
 * 生成不同平台的CSS实现
 * @param {string} className - 类名
 * @param {Object} styles - 基础样式
 * @param {Object} options - 选项
 * @returns {Object} 不同平台的CSS实现
 */
export function generatePlatformSpecificCSS(className, styles, options = {}) {
    const { mode = 'development' } = options;
    const decodedClassName = utils.decodeClassNameFromUvue(className);
    
    // 针对 text-ellipsis 类名的特殊处理
    if (/^text-ellipsis-(\d+|\[\d+\])$/.test(decodedClassName)) {
        const match = decodedClassName.match(/^text-ellipsis-(\d+|\[\d+\])$/);
        let numValue = match[1];
        
        // 处理方括号语法 [2] -> 2
        if (numValue.startsWith('[') && numValue.endsWith(']')) {
            numValue = numValue.slice(1, -1);
        }
        
        const lines = parseInt(numValue);
        
        if (lines >= 1 && lines <= 10) {
            return {
                // Web端：使用CSS方案
                web: lines === 1 ? {
                    'overflow': 'hidden',
                    'text-overflow': 'ellipsis',
                    'white-space': 'nowrap'
                } : {
                    'overflow': 'hidden',
                    'text-overflow': 'ellipsis',
                    'display': '-webkit-box',
                    '-webkit-line-clamp': lines.toString(),
                    '-webkit-box-orient': 'vertical'
                },
                // 小程序端：现代小程序支持webkit方案
                mp: lines === 1 ? {
                    'overflow': 'hidden',
                    'text-overflow': 'ellipsis',
                    'white-space': 'nowrap'
                } : {
                    'overflow': 'hidden',
                    'text-overflow': 'ellipsis',
                    'display': '-webkit-box',
                    '-webkit-line-clamp': lines.toString(),
                    '-webkit-box-orient': 'vertical'
                },
                // App端：使用原生lines属性
                app: {
                    'lines': lines,
                    'text-overflow': 'ellipsis',
                    'overflow': 'hidden'
                },
                // 鸿蒙端：使用原生lines属性
                harmony: {
                    'lines': lines,
                    'text-overflow': 'ellipsis',
                    'overflow': 'hidden'
                }
            };
        }
    }
    
    // 针对 lines-* 类名的特殊处理（App专有）
    if (/^lines-(\d+|\[\d+\])$/.test(decodedClassName)) {
        const match = decodedClassName.match(/^lines-(\d+|\[\d+\])$/);
        let numValue = match[1];
        
        if (numValue.startsWith('[') && numValue.endsWith(']')) {
            numValue = numValue.slice(1, -1);
        }
        
        const lines = parseInt(numValue);
        
        if (lines >= 0) {
            return {
                web: null,  // Web端不支持lines属性
                mp: null,   // 小程序端不支持lines属性
                app: {      // 仅App端支持
                    'lines': lines === 0 ? -1 : lines  // 0转换为-1（不限制）
                },
                harmony: {  // 鸿蒙端支持
                    'lines': lines === 0 ? -1 : lines
                }
            };
        }
    }
    
    // 针对 background-clip 的特殊处理
    if (/^bg-clip-/.test(decodedClassName)) {
        const clipMatch = decodedClassName.match(/^bg-clip-(border|padding|content|text)$/);
        if (clipMatch) {
            const [, clipType] = clipMatch;
            const clipValueMap = {
                'border': 'border-box',
                'padding': 'padding-box',
                'content': 'content-box',
                'text': 'text'
            };
            
            const clipValue = clipValueMap[clipType];
            if (clipValue) {
                return {
                    web: { 'background-clip': clipValue },      // Web端支持全部值
                    mp: clipType !== 'text' ? { 'background-clip': clipValue } : null,  // 小程序端不支持text值
                    app: clipType === 'border' ? { 'background-clip': clipValue } : null,  // App端仅支持border-box
                    harmony: clipType === 'border' ? { 'background-clip': clipValue } : null
                };
            }
        }
    }
    
    // 针对包含app-only属性的处理
    for (const [property, value] of Object.entries(styles)) {
        if (CSS_COMPATIBILITY['app-only'].includes(property)) {
            return {
                web: null,
                mp: null,
                app: styles,
                harmony: styles
            };
        }
        
        if (CSS_COMPATIBILITY['web-only'].includes(property)) {
            return {
                web: styles,
                mp: null,
                app: null,
                harmony: null
            };
        }
    }
    
    // 默认情况：所有平台使用相同的样式
    return {
        web: styles,
        mp: styles,
        app: styles,
        harmony: styles
    };
}

/**
 * 生成条件编译CSS规则
 * @param {string} selector - CSS选择器
 * @param {Object} platformStyles - 不同平台的样式 {web: {}, mp: {}, app: {}, harmony: {}}
 * @param {Object} options - 选项
 * @returns {string} 带条件编译的CSS字符串
 */
export function generateConditionalCSSRule(selector, platformStyles, options = {}) {
    const { mode = 'development', compileAllPlatforms = true } = options;
    const isProduction = mode === 'production';
    
    // 如果不编译全端，只生成当前运行环境的代码
    if (!compileAllPlatforms) {
        const currentPlatform = detectCurrentPlatform();
        const currentStyles = platformStyles[currentPlatform];
        
        if (!currentStyles) {
            return '';
        }
        
        return formatCSSRule(selector, currentStyles, isProduction);
    }
    
    // 编译全端代码
    let css = '';
    
    // Web平台
    if (platformStyles.web) {
        css += `/* #ifdef H5 */\n`;
        css += formatCSSRule(selector, platformStyles.web, isProduction);
        css += `\n/* #endif */\n\n`;
    }
    
    // 小程序平台（兼容多个小程序平台）
    if (platformStyles.mp) {
        css += `/* #ifdef MP-WEIXIN || MP-ALIPAY || MP-BAIDU || MP-TOUTIAO || MP-QQ || MP-KUAISHOU || MP-DINGTALK || MP-XIAO-HONG-SHU */\n`;
        css += formatCSSRule(selector, platformStyles.mp, isProduction);
        css += `\n/* #endif */\n\n`;
    }
    
    // App平台（包含Android和iOS）
    if (platformStyles.app) {
        css += `/* #ifdef APP-PLUS || APP-ANDROID || APP-IOS */\n`;
        css += formatCSSRule(selector, platformStyles.app, isProduction);
        css += `\n/* #endif */\n\n`;
    }
    
    // 鸿蒙平台
    if (platformStyles.harmony) {
        css += `/* #ifdef MP-HARMONY */\n`;
        css += formatCSSRule(selector, platformStyles.harmony, isProduction);
        css += `\n/* #endif */`;
    }
    
    return css.trim();
}

/**
 * 格式化CSS规则
 * @param {string} selector - CSS选择器
 * @param {Object} styles - 样式对象
 * @param {boolean} isProduction - 是否为生产环境
 * @returns {string} 格式化的CSS规则
 */
function formatCSSRule(selector, styles, isProduction) {
    if (!styles || Object.keys(styles).length === 0) {
        return '';
    }
    
    if (isProduction) {
        const cssProps = Object.entries(styles)
            .filter(([prop]) => !prop.startsWith('__'))
            .map(([prop, value]) => `${prop}:${value}`)
            .join(';');
        return `.${selector}{${cssProps}}`;
    } else {
        let css = `.${selector} {\n`;
        Object.entries(styles).forEach(([prop, value]) => {
            if (!prop.startsWith('__')) {
                css += `  ${prop}: ${value};\n`;
            }
        });
        css += `}`;
        return css;
    }
}

/**
 * 检测当前运行环境
 * @returns {string} 当前平台标识 'web' | 'mp' | 'app' | 'harmony'
 */
function detectCurrentPlatform() {
    // 检测当前运行环境
    if (typeof window !== 'undefined') {
        // 浏览器环境
        return 'web';
    } else if (typeof wx !== 'undefined' || typeof my !== 'undefined' || 
               typeof swan !== 'undefined' || typeof tt !== 'undefined' || 
               typeof qq !== 'undefined' || typeof ks !== 'undefined') {
        // 小程序环境
        return 'mp';
    } else if (typeof harmony !== 'undefined' || 
               (typeof globalThis !== 'undefined' && globalThis.harmony)) {
        // 鸿蒙环境
        return 'harmony';
    } else if (typeof plus !== 'undefined' || typeof uni !== 'undefined') {
        // App环境
        return 'app';
    } else {
        // 默认返回Web
        return 'web';
    }
}

// 为了向后兼容，保持原有的h5/mp/app接口
export function generateConditionalCSSRuleLegacy(selector, platformStyles, options = {}) {
    // 转换新格式到旧格式
    const legacyPlatformStyles = {
        web: platformStyles.h5 || platformStyles.web,
        mp: platformStyles.mp,
        app: platformStyles.app,
        harmony: platformStyles.harmony
    };
    
    return generateConditionalCSSRule(selector, legacyPlatformStyles, options);
} 